package com.library.controller;

import com.library.dto.BookDTO;
import com.library.dto.PageResponse;
import com.library.service.BookService;
import jakarta.validation.Valid;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;

import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * 图书控制器
 * 处理图书相关的HTTP请求，包括搜索、查询、创建、更新、删除等操作
 */
@Slf4j
@RestController
@RequestMapping("/api/books")
@RequiredArgsConstructor
public class BookController {
    // 注入图书服务，处理业务逻辑
    private final BookService bookService;

    /**
     * 搜索图书接口
     * GET /api/books?keyword=xxx&category=xxx&is_recommended=true&page=1&size=20&sort=title&order=asc
     * 支持按关键词、分类、推荐状态搜索，支持分页和排序
     * 
     * @param keyword 搜索关键词（可选），会在书名、作者、ISBN中搜索
     * @param category 图书分类（可选），精确匹配
     * @param is_recommended 是否推荐（可选），"true"表示只搜索推荐图书
     * @param page 页码（可选）
     * @param size 每页大小（可选）
     * @param sort 排序字段（可选）
     * @param order 排序方向（可选）
     * @return 符合条件的图书列表（当未提供分页参数时返回 {books:[...] }；提供分页参数时返回分页对象）
     */
    @GetMapping
    public ResponseEntity<Object> searchBooks(
            @RequestParam(required = false) String keyword,
            @RequestParam(required = false) String category,
            @RequestParam(required = false) String is_recommended,
            @RequestParam(required = false) Integer page,
            @RequestParam(required = false) Integer size,
            @RequestParam(required = false) String sort,
            @RequestParam(required = false) String order) {
        // 将字符串参数转换为布尔值，如果未提供则设为null
        Boolean isRecommended = null;
        if (is_recommended != null && !is_recommended.isEmpty()) {
            isRecommended = "true".equalsIgnoreCase(is_recommended);
        }
        
        // 如果提供了分页参数，使用分页查询
        if (page != null && size != null) {
            int pageNum = page > 0 ? page : 1;
            int pageSize = (size > 0 && size <= 100) ? size : 20;
            String sortField = (sort != null && !sort.isEmpty()) ? sort : "createdAt";
            String sortOrder = (order != null && !order.isEmpty() && ("asc".equalsIgnoreCase(order) || "desc".equalsIgnoreCase(order))) ? order : "desc";

            log.debug("接收搜索请求(分页) - keyword: [{}], category: [{}], is_recommended: [{}], page: {}, size: {}, sort: {}, order: {}", 
                    keyword, category, is_recommended, pageNum, pageSize, sortField, sortOrder);

            PageResponse<BookDTO> pageResponse =
                bookService.searchBooksWithPagination(keyword, category, isRecommended,
                    pageNum, pageSize, sortField, sortOrder);
            return ResponseEntity.ok(pageResponse);
        } else {
            // 否则使用不分页查询，并返回 { "books": [...] } 结构（用于测试文档示例）
            log.debug("接收搜索请求(不分页) - keyword: [{}], category: [{}], is_recommended: [{}]", 
                    keyword, category, is_recommended);
            List<BookDTO> books = bookService.searchBooks(keyword, category, isRecommended);
            Map<String, List<BookDTO>> response = new HashMap<>();
            response.put("books", books);
            return ResponseEntity.ok(response);
        }
    }
//    @GetMapping
//    public ResponseEntity<Object> searchBooks(
//            @RequestParam(required = false) String keyword,
//            @RequestParam(required = false) String category,
//            @RequestParam(required = false) String is_recommended,
//            @RequestParam(required = false) Integer page,
//            @RequestParam(required = false) Integer size,
//            @RequestParam(required = false) String sort,
//            @RequestParam(required = false) String order) {
//
//        // 将字符串参数转换为布尔值
//        Boolean isRecommended = null;
//        if (is_recommended != null && !is_recommended.isEmpty()) {
//            isRecommended = "true".equalsIgnoreCase(is_recommended);
//        }
//
//        // 如果提供了分页参数，使用分页查询
//        if (page != null && size != null) {
//            int pageNum = page > 0 ? page : 1;
//            int pageSize = size > 0 ? size : 20;
//            String sortField = (sort != null && !sort.isEmpty()) ? sort : "createdAt";
//            String sortOrder = (order != null && !order.isEmpty()) ? order : "desc";
//
//            com.library.dto.PageResponse<BookDTO> pageResponse =
//                bookService.searchBooksWithPagination(keyword, category, isRecommended,
//                    pageNum, pageSize, sortField, sortOrder);
//            return ResponseEntity.ok(pageResponse);
//        } else {
//            // 否则使用原来的不分页查询
//            List<BookDTO> books = bookService.searchBooks(keyword, category, isRecommended);
//            Map<String, List<BookDTO>> response = new HashMap<>();
//            response.put("books", books);
//            return ResponseEntity.ok(response);
//        }
//    }

    /**
     * 获取图书详情接口
     * GET /api/books/{id}
     * 
     * @param id 图书ID
     * @return 图书详情
     */
    @GetMapping("/{id}")
    public ResponseEntity<Map<String, BookDTO>> getBook(@PathVariable Long id) {
        BookDTO book = bookService.getBookById(id);
        Map<String, BookDTO> response = new HashMap<>();
        response.put("book", book);
        return ResponseEntity.ok(response);
    }

    /**
     * 创建图书接口
     * POST /api/books
     * 管理员专用功能
     * 
     * @param dto 图书信息
     * @param role 用户角色（从JWT中获取）
     * @return 创建结果，包含新创建的图书ID
     */
    @PostMapping
    public ResponseEntity<Map<String, Object>> createBook(
            @Valid @RequestBody BookDTO dto,
            @RequestAttribute String role) {
        
        // 检查管理员权限
        if (!"admin".equals(role)) {
            throw new com.library.exception.ForbiddenException("需要管理员权限");
        }
        
        // 创建图书
        BookDTO book = bookService.createBook(dto);
        Map<String, Object> response = new HashMap<>();
        response.put("message", "添加成功");
        response.put("id", book.getId());
        return ResponseEntity.ok(response);
    }

    /**
     * 更新图书接口
     * PUT /api/books/{id}
     * 管理员专用功能
     * 
     * @param id 图书ID
     * @param dto 更新的图书信息
     * @param role 用户角色（从JWT中获取）
     * @return 更新结果
     */
    @PutMapping("/{id}")
    public ResponseEntity<Map<String, String>> updateBook(
            @PathVariable Long id,
            @Valid @RequestBody BookDTO dto,
            @RequestAttribute String role) {
        
        // 检查管理员权限
        if (!"admin".equals(role)) {
            throw new com.library.exception.ForbiddenException("需要管理员权限");
        }
        
        // 更新图书
        bookService.updateBook(id, dto);
        Map<String, String> response = new HashMap<>();
        response.put("message", "更新成功");
        return ResponseEntity.ok(response);
    }

    /**
     * 删除图书接口
     * DELETE /api/books/{id}
     * 管理员专用功能
     * 
     * @param id 图书ID
     * @param role 用户角色（从JWT中获取）
     * @return 删除结果
     */
    @DeleteMapping("/{id}")
    public ResponseEntity<Map<String, String>> deleteBook(
            @PathVariable Long id,
            @RequestAttribute String role) {
        
        // 检查管理员权限
        if (!"admin".equals(role)) {
            throw new com.library.exception.ForbiddenException("需要管理员权限");
        }
        
        // 删除图书
        bookService.deleteBook(id);
        Map<String, String> response = new HashMap<>();
        response.put("message", "删除成功");
        return ResponseEntity.ok(response);
    }

    /**
     * 获取所有图书分类接口
     * GET /api/books/categories/list
     * 
     * @return 所有分类列表
     */
    @GetMapping("/categories/list")
    public ResponseEntity<Map<String, List<String>>> getCategories() {
        List<String> categories = bookService.getAllCategories();
        Map<String, List<String>> response = new HashMap<>();
        response.put("categories", categories);
        return ResponseEntity.ok(response);
    }

    /**
     * 获取图书统计信息接口
     * GET /api/books/statistics
     * 管理员专用功能
     * 
     * @param role 用户角色（从JWT中获取）
     * @return 图书统计信息
     */
    @GetMapping("/statistics")
    public ResponseEntity<Map<String, Object>> getBookStatistics(
            @RequestAttribute String role) {
        
        // 检查管理员权限
        if (!"admin".equals(role)) {
            throw new com.library.exception.ForbiddenException("需要管理员权限");
        }
        
        Map<String, Object> statistics = bookService.getBookStatistics();
        return ResponseEntity.ok(statistics);
    }

    /**
     * 批量删除图书接口
     * DELETE /api/books/batch
     * 管理员专用功能
     * 
     * @param request 请求体，包含bookIds（图书ID列表）
     * @param role 用户角色（从JWT中获取）
     * @return 删除结果
     */
    @DeleteMapping("/batch")
    public ResponseEntity<Map<String, String>> deleteBooksBatch(
            @RequestBody Map<String, List<Long>> request,
            @RequestAttribute String role) {
        
        // 检查管理员权限
        if (!"admin".equals(role)) {
            throw new com.library.exception.ForbiddenException("需要管理员权限");
        }
        
        List<Long> bookIds = request.get("bookIds");
        bookService.deleteBooksBatch(bookIds);
        
        Map<String, String> response = new HashMap<>();
        response.put("message", "批量删除成功");
        return ResponseEntity.ok(response);
    }

    /**
     * 批量更新图书接口
     * PUT /api/books/batch
     * 管理员专用功能
     * 
     * @param request 请求体，包含books（图书列表）
     * @param role 用户角色（从JWT中获取）
     * @return 更新结果
     */
    @PutMapping("/batch")
    public ResponseEntity<Map<String, String>> updateBooksBatch(
            @RequestBody Map<String, List<BookDTO>> request,
            @RequestAttribute String role) {
        
        // 检查管理员权限
        if (!"admin".equals(role)) {
            throw new com.library.exception.ForbiddenException("需要管理员权限");
        }
        
        List<BookDTO> books = request.get("books");
        bookService.updateBooksBatch(books);
        
        Map<String, String> response = new HashMap<>();
        response.put("message", "批量更新成功");
        return ResponseEntity.ok(response);
    }
}
